package com.li.java1;

/**
 * @author 喂S别闹
 * @create 2022/4/20-10:14
 * @Version 1.0
 * @Description: 使用
 */

import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @Date: 2022/4/20 10:18
 * @Auther: 喂S别闹
 * @param: null
 * @Return: null
 * @Description:
 *    Lambda的使用
 *    比如： (o1,o2) -> Integer . compare(o1,o2)
 *    格式：
 *    -> Lambda操作符
 *    左边：Lambda形参列表（接口中的抽象方法的形参列表）
 *    左边：Lambda体（就是重写的抽象方法的方法体）
 *
 *    Lambda 有6中使用
 *    lambda 是接口的实例
 */
public class LambdaTest1  {

    /**
     * @Date: 2022/4/20 10:23
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:格式一  无参，无返回值
     */
    @Test
    public void test1(){
        Runnable r1 = ()-> {
            System.out.println("这是Lambda表达式");
        };
        r1.run();
    }
    
    /**
     * @Date: 2022/4/20 10:23
     * @Auther: 喂S别闹
     * @param: 
     * @Return: void
     * @Description:格式二 Lambda需要一个参数，但是没有返回值
     */
    @Test
    public void test2(){
        Consumer<String> s = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        s.accept("原生");
//--------------------------
        Consumer<String> s1 = (String s2) -> {
            System.out.println(s2);
        };
        s1.accept("Lambda");
    }

    /**
     * @Date: 2022/4/20 10:33
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description: 格式三： 数据类型可以省略，由编译器自己推算
     */
    @Test
    public void test3(){
        Consumer<String> con1 = (String s) -> {
            System.out.println(s);
        };
        con1.accept("lambda");

        System.out.println("------------");
        Consumer<String> con2 = (s)-> {
            System.out.println(s);
        };
        con2.accept("推断");


    }
    
    /**
     * @Date: 2022/4/20 10:43
     * @Auther: 喂S别闹
     * @param: 
     * @Return: void
     * @Description:格式4：若参数只有一个小括号也可以省略
     */
    @Test
    public void test4(){
        //
        Consumer<String> con3 = s-> {
            System.out.println(s);
        };
        con3.accept("小括号 ");
    }

    /**
     * @Date: 2022/4/20 10:47
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:lambda需要两个或以上的参数，多条执行语句，并且可以有返回值
     */
    @Test
    public void test5(){
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        int compare = com1.compare(12, 21);
        System.out.println(compare);
        System.out.println("----------------------");
        Comparator<Integer> com2 = (o1,o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        int compare1 = com2.compare(21, 12);
        System.out.println(compare1);
    }

    /**
     * @Date: 2022/4/20 10:55
     * @Auther: 喂S别闹
     * @param:
     * @Return: void
     * @Description:当Lambda体只有一条语句时，return与大括号都可以省略
     */
    @Test
    public void test6(){

        Comparator<Integer> com1 = (o1,o2) -> {
            return o1.compareTo(o2);
        };
        int compare = com1.compare(21, 12);
        System.out.println(compare);

        System.out.println("------------------------");
        Comparator<Integer> com2 = (o1,o2) ->  o1.compareTo(o2);
        int compare1 = com2.compare(21, 12);
        System.out.println(compare1);

        System.out.println("---------------");

        Consumer<String> con3 = (s) -> System.out.println(s);
        con3.accept("消费者");
    }


}
